package com.mall.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.mall.domain.dto.ItemDTO;
import com.mall.domain.po.Item;
import com.mall.service.ItemService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * 推荐控制器，处理今日推荐和猜你喜欢的请求
 */
@Slf4j
@RestController
@RequestMapping
@RequiredArgsConstructor
public class RecommendController {

    private final RedisTemplate<String, Object> redisTemplate;
    private final ItemService itemService;

    /**
     * 今日推荐接口
     * 返回销量前12的商品作为今日推荐
     */
    @GetMapping("/today-recommend")
    public List<Map<String, Object>> getTodayRecommend() {
        log.info("获取今日推荐商品");
        long startTime = System.currentTimeMillis();
        
        // 查询销量前4的商品
        QueryWrapper<Item> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("sold")
                .last("LIMIT 12");
        
        List<Item> items = itemService.list(queryWrapper);
        
        // 转换为前端需要的数据格式
        List<Map<String, Object>> result = items.stream().map(item -> {
            Map<String, Object> map = new HashMap<>();
            map.put("id", item.getId());
            map.put("image", item.getImage());
            map.put("title", item.getName());
            return map;
        }).collect(Collectors.toList());
        
        long endTime = System.currentTimeMillis();
        log.info("今日推荐接口耗时：{} 毫秒", endTime - startTime);
        return result;
    }

    /**
     * 猜你喜欢接口
     * 返回随机的12个商品
     */
    @GetMapping("/guess-you-like")
    public List<Map<String, Object>> getGuessYouLike() {
        log.info("获取猜你喜欢商品");
        long startTime = System.currentTimeMillis();
        
        // 尝试从 Redis 获取缓存的商品 ID 集合
        String cacheKey = "guess_you_like:item_ids";
        Object cachedData = redisTemplate.opsForValue().get(cacheKey);
        Set<Long> cachedItemIds = null;
        
        // 如果缓存存在，转换为 Set<Long>
        if (cachedData != null) {
            if (cachedData instanceof Set) {//判断 cachedData 是否为 Set 类型。
                // 处理 Set 中的 Integer 转换为 Long
                cachedItemIds = ((Set<?>) cachedData).stream()
                        .map(id -> ((Number) id).longValue())
                        .collect(Collectors.toSet());
            } else if (cachedData instanceof Collection) {
                // 处理 Collection 中的 Integer 转换为 Long
                cachedItemIds = ((Collection<?>) cachedData).stream()
                        .map(id -> ((Number) id).longValue())
                        .collect(Collectors.toSet());
            }
        }
        
        // 如果缓存不存在或转换失败，查询数据库获取所有商品 ID 并缓存
        if (cachedItemIds == null) {
            QueryWrapper<Item> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("status", 1).select("id"); // 只查询 ID
            List<Item> allItems = itemService.list(queryWrapper);
            cachedItemIds = allItems.stream().map(Item::getId).collect(Collectors.toSet());
            redisTemplate.opsForValue().set(cacheKey, cachedItemIds, 5, TimeUnit.MINUTES);
        }
        
        // 如果商品数量小于12，直接返回所有商品
        if (cachedItemIds.size() <= 12) {
            List<Item> items = itemService.listByIds(new ArrayList<>(cachedItemIds));
            long endTime = System.currentTimeMillis();
            log.info("猜你喜欢接口耗时：{} 毫秒", endTime - startTime);
            return convertToGuessLikeFormat(items);
        }
        
        // 随机选择12个商品 ID
        List<Long> randomItemIds = new ArrayList<>();
        Random random = new Random();
        Set<Integer> selectedIndices = new HashSet<>();
        List<Long> itemIdList = new ArrayList<>(cachedItemIds);
        
        while (selectedIndices.size() < 12) {
            int index = random.nextInt(itemIdList.size());
            if (!selectedIndices.contains(index)) {
                selectedIndices.add(index);
                randomItemIds.add(itemIdList.get(index));
            }
        }
        
        // 查询商品详情
        List<Item> randomItems = itemService.listByIds(randomItemIds);
        
        long endTime = System.currentTimeMillis();
        log.info("猜你喜欢接口耗时：{} 毫秒", endTime - startTime);
        return convertToGuessLikeFormat(randomItems);
    }
    
    /**
     * 将商品列表转换为猜你喜欢接口需要的数据格式
     */
    private List<Map<String, Object>> convertToGuessLikeFormat(List<Item> items) {
        return items.stream().map(item -> {
            Map<String, Object> result = new HashMap<>();
            result.put("id", item.getId());
            result.put("image", item.getImage());
            result.put("title", item.getName());
            
            // 将商品名称分割为描述列表
            List<String> descriptions = new ArrayList<>();
            String name = item.getName();
//            if (name.length() > 20) {
//                // 如果名称过长，分割成两行显示
//                descriptions.add(name.substring(0, 20));
//                descriptions.add(name.substring(20));
//            } else {
//                descriptions.add(name);
//            }
            descriptions.add(name);
            result.put("descriptions", descriptions);
            
            // 价格转换为元并保留两位小数
            String price = "¥" + String.format("%.2f", item.getPrice() / 100.0);
            result.put("price", price);
            
            return result;
        }).collect(Collectors.toList());
    }
}